// 1、关键字
// 2、命名空间
// 3、C++输入&输出
// 4、缺省参数
// 5、函数重载
// 6、引用
// 7、内联函数
// 8、auto关键字
// 9、基于范围的for循环
// 10、指针空值nullptr

// #include <stdio.h>
// #include <stdlib.h>

// int a = 0;
// int main()
// {
//     int a = 5;
//     printf("%d\n",a);

//     // ::域作用限定符:访问全局域
//     printf("%d\n",::a);

//     system("pause");
//     return 0;
// }

// // 全局域
// int a = 0;

// // 命名空间域
// namespace tmp
// {
//     int a = 1;
// }
// // 优先使用局部域，其次全局域
// // 展开命名空间域 或者 指定访问命名空间域

// // 展开命名空间域
// using namespace tmp;

// int main()
// {
//     // 局部域
//     int a = 2;

//     printf("%d\n",a);
//     printf("%d\n",::a);

//     // 指定访问命名空间域
//     printf("%d\n",tmp::a);
//     return 0;
// }

// namespace lib
// {
//     int rand = 0;
// }
// int main()
// {
//     printf("%p\n",rand);
//     printf("%p\n",&lib::rand);
//     printf("%d\n",lib::rand);

//     system("pause");
//     return 0 ;
// }

// // 命名空间域的嵌套
// namespace n1
// {
//     int a = 0;
//     int b;
//     int Add(int left,int right)
//     {
//         return left + right;
//     }
//     namespace n2
//     {
//         int a = 1;
//         int c;
//         int d;
//         int Sub(int left,int right)
//         {
//             return left - right;
//         }
//     }
// }
// int main()
// {
//     printf("%d\n",n1::a);
//     printf("%d\n",n1::n2::a);
//     printf("%d\n",n1::Add(5,5));
//     printf("%d\n",n1::n2::Sub(5,5));

//     system("pause");
//     return 0;
// }

// #include <iostream>
// namespace Fnames_1
// {
//     int a = 10;
//     int b = 20;
// }
// using namespace Fnames_1;
// int main()
// {
//     int b = 0;
//     printf("%d\n",Fnames_1::a);
//     printf("%d\n",a);
//     std::cout << b << std::endl;

//     return 0;
// }

// #include <iostream>
// #include <list>

// // using namespace std;
// // // 直接展开有风险，定义如果和库重名，就报错了

// // 展开某个：展开常用，不常用的指定搜索
// using std::cout;
// using std::endl;
// using std::cin;

// int main()
// {
//     int x = 0;
//     double d = 11.11;

//     cout << x << endl << d << endl;
//     cin >> x >> d;
//     cout << x << endl << d << endl;

//     system("pause");
//     return 0;
// }

// // 缺省参数
// #include <iostream>

// using std::cout;
// using std::endl;

// // 缺省参数：声明和定义不能同时有缺省值，声明有了，定义就不能有，建议在声明放缺省值
// // 半缺省参数必须从右往左给，不能间隔着给
// // 缺省值必须是常量或者全局变量
// // 全缺省参数
// void func(int a = 10,int b = 20,int c = 30)
// {
//     cout << "a = " << a << endl;
//     cout << "b = " << b << endl;
//     cout << "c = " << c << endl << endl;
// }
// // 半缺省参数
// void Func(int a,int b = 10,int c = 20)
// {
//     cout << "a = " << a << endl;
//     cout << "b = " << b << endl;
//     cout << "c = " << c << endl << endl;
// }
// int main()
// {
//     func();
//     func(1);
//     func(1,2);
//     func(1,2,3);

//     system("pause");
//     return 0;
// }

// // 函数重载
// // C++允许在同一作用域中声明几个功能类似的同名函数
// // 这些同名函数的形参列表(参数个数或类型或类型顺序)不同
// #include <iostream>
// using std::cout;
// using std::endl;
// // 参数类型不同
// int Add(int left,int right)
// {
//     cout << "int Add(int left,int right)" << endl;
//     return left+right;
// }
// double Add(double left,double right)
// {
//     cout << "double Add(double left,double right)" << endl;
//     return left+right;
// }
// // 参数个数不同
// void f()
// {
//     cout << "f()" << endl;
// }
// void f(int a)
// {
//     cout << "f(int a)" << endl;
// }
// // 参数类型顺序不同
// void f(int a,char b)
// {
//     cout << "f(int a,int b)" << endl;
// }
// void f(char b,int a)
// {
//     cout << "f(char b,int a)" << endl;
// }
// int main()
// {
//     Add(10,20);
//     Add(10.1,20.2);

//     f();
//     f(10);

//     f(10,'a');
//     f('a',10);

//     system("pause");
//     return 0;
// }

// // 引用&
// #include <iostream>
// using std::cout;
// using std::endl;
// int main()
// {
//     int a = 10;
//     int& b = a;

//     int c = 20;

//     cout << "a = " << a << endl;
//     cout << "b = " << b << endl;

//     system("pause");
//     return 0;
// }

// // 1、引用做参数（输出型参数）
// // 2、引用做参数（提高效率）（大对象/深拷贝类对象）
// #include <iostream>
// using std::cout;
// using std::endl;

// void Swap(int& left,int& right)
// {
//     int temp = left;
//     left = right;
//     right = temp;
// }
// int main()
// {
//     int a = 10;
//     int b = 20;
//     Swap(a,b);
//     cout << "a = " << a << endl;
//     cout << "b = " << b << endl;

//     system("pause");
//     return 0;
// }

// #include<iostream>
// using namespace std;
// int& Count()
// {
//     static int n = 10;
//     n++;

//     return n;
// }
// int main()
// {
//     int ret = Count();
//     cout << ret << endl;

//     return 0;
// }

// #include <iostream>
// using namespace std;

// int& Count()
// {
//     static int n;
//     n++;
//     return n;
// }
// int main()
// {
//     int& ret = Count();
//     cout << ret << endl;

//     Count();
//     cout << ret << endl;

//     system("pause");
//     return 0;
// }

// #include <iostream>
// #include <time.h>
// using std::cout;
// using std::endl;
// struct A{ int a[10000]; };

// A a;

// // 值返回
// A TestFunc1(A a) { return a;}

// // 引用返回
// A& TestFunc2(A& a){ return a;}

// void TestReturnByRefOrValue()
// {
//     // 以值作为函数的返回值类型
//     size_t begin1 = clock();
//     for (size_t i = 0; i < 10000; ++i)
//         TestFunc1(a);
//     size_t end1 = clock();

//     // 以引用作为函数的返回值类型
//     size_t begin2 = clock();
//     for (size_t i = 0; i < 10000; ++i)
//         TestFunc2(a);
//     size_t end2 = clock();

//     // 计算两个函数运算完成之后的时间
//     cout << "TestFunc1 time:" << end1 - begin1 << endl;
//     cout << "TestFunc2 time:" << end2 - begin2 << endl;
// }
// int main()
// {
//     TestReturnByRefOrValue();

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using std::cout;
// using std::endl;

// int& Add(int& a)
// {
//     static int c = a;
//     c++;
//     return c;
// }
// int main()
// {
//     int i = 1;
//     Add(i) = i + 10;

//     cout << "Add(i) = " << Add(i) << endl;

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// int main()
// {
//     // 不可以
//     // 引用过程中，权限不能放大
//     const int a = 0;
//     // int& b = a;

//     // 可以，c拷贝给d，没有放大权限，因为d的改变不影响c
//     const int c = 0;
//     int d = c;

//     // 可以，权限可以平移或者缩小
//     int x = 0;
//     // 权限的平移
//     int& y = x;
//     // 权限的缩小
//     const int& z = x;
//     ++x;

//     cout << "x = " << x << endl;
//     cout << "y = " << y << endl;
//     cout << "z = " << z << endl;

//     return 0;
// }

// #include <iostream>
// using namespace std;
// int func1()
// {
//     static int x = 0;
//     return x;
// }
// int& func2()
// {
//     static int x = 0;
//     return x;
// }
// int main()
// {
//     // // 权限的放大：在赋值时，会先把值赋给有常性的临时变量，即在原本的变量前加了const，
//     // // 相同类型不会产生临时变量
//     // int& ret1 = func1();

//     // // 权限的平移
//     // const int& ret1 = func1();

//     // int ret1 = func1();     // 拷贝

//     int& ret2 = func2();        // 权限平移
//     const int& ret2 = func2();  // 权限缩小


//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// int main()
// {
//     int n = 10;
//     int& a = n;
//     int b = 1;
//     a = b;      //赋值

//     cout << a << endl;
//     cout << b << endl;

//     b = 20;

//     cout << a << endl;
//     cout << b << endl;

//     return 0;
// }

// #include <iostream>
// using std::cout;
// using std::endl;
// int main()
// {
//     int a = 0;
//     int b = a;

//     // 根据右边的表达式自动推导c的类型
//     auto c = a;
//     // 根据右边的表达式自动推导d的类型
//     auto d = 1 + 1.11;

//     // typeid打印变量类型
//     cout << typeid(c).name() << endl;
//     cout << typeid(d).name() << endl;

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;

// int main()
// {
//     int arr[] = {1,2,3,4,5};
//     for(int i = 0;i < sizeof(arr) / sizeof(int);i++)
//         arr[i] *= 2;

//     for(int* p = arr;p < arr+sizeof(arr) / sizeof(arr[0]);p++)
//         cout << *p << " ";
//     cout << endl;

//     // 适用于数组
//     // 范围for
//     // 依次取数组中数据赋值给e
//     // 自动迭代，自动判断结束
//     for(auto& e:arr)
//     {
//         e *= 2;
//     }

//     //修改
//     for(auto e:arr)
//     {
//         cout << e << " ";
//     }
//     cout << endl;

//     system("pause");
//     return 0;
// }


// #include <iostream>

// // 宏函数
// // 优点：不需要建立栈帧，提高调用效率
// // 缺点：复杂，容易出错，可读性差，不能调试

// // #define Add(x,y) (x+y)
// using namespace std;

// // 内联函数 关键字：inline
// // 适用于短小的频繁调用的函数
// // inline对于编译器仅仅只是一个建议，最终是否成为inline，编译器自己决定
// // 像类似函数加了inline也会被否决掉
// // 1、比较长的函数
// // 2、递归函数
// inline int Add(int x,int y)
// {
//     return (x+y)*10;
// }
// int main()
// {
//     for(int i = 0;i < 10000;i++)
//     {
//         cout << Add(i,i+1) << endl;
//     }
// }

// #include <string>
// #include <map>
// int main()
// {
//     std::map<std::string,std::string>m{{"apple","苹果"},{"orange","橙子"}};
//     std::map<std::string,std::string>::iterator it = m.begin();
//     while(it != m.end())
//     {
//         // ...
//     }
//     return 0;
// }

// #include <iostream>
// using std::cout;
// using std::endl;

// auto TestAuto()
// {
//     return 10;
// }
// int main()
// {
//     int a = 10;
//     auto b = a;
//     auto c = 'a';
//     auto d = TestAuto();
//     // auto e; // 无法通过编译，使用auto定义变量时必须对其进行初始化

//     cout << typeid(b).name() << endl;
//     cout << typeid(c).name() << endl;
//     cout << typeid(d).name() << endl;

//     return 0;
// }

// int main()
// {
//     int x = 10;
//     auto a = &x;
//     auto* b = &x;
//     auto& c = x;
//     cout << typeid(a).name() << endl;
//     cout << typeid(b).name() << endl;
//     cout << typeid(c).name() << endl;

//     *a = 20;
//     *b = 30;
//     c = 40;

//     return 0;
// }

#include <iostream>
using namespace std;

int main()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
        e *= 2;
    
    for(auto e : array)
        cout << e << " ";
        
    return 0;
}